package org.ehe.business.overdue;

import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.ehe.business.overdue.handler.OverdueHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 超期管理器 - 统一调度处理
 * @author :zhangnn
 * @className :OverdueManager
 * @description: TODO
 * @date 2025-07-29 15:54:01
 */
@Component
@Slf4j
public class OverdueManager {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private List<OverdueHandler> overdueHandlers;

    private Map<String, OverdueHandler> handlerMap;

    @PostConstruct
    public void init() {
        // 构建业务类型到处理器的映射
        handlerMap = overdueHandlers.stream()
            .collect(Collectors.toMap(
                OverdueHandler::getBizType,
                Function.identity()
            ));
        log.info("初始化超期处理器完成，支持的业务类型: {}", handlerMap.keySet());
    }

    /**
     * 定时处理超期任务
     */
    @Scheduled(fixedRate = 30000) // 每30秒执行一次
    public void processOverdueTasks() {
        processTasksFromQueue("overdue:tasks", false);
    }

    /**
     * 定时处理提醒任务
     */
    @Scheduled(fixedRate = 60000) // 每1分钟执行一次
    public void processRemindTasks() {
        processTasksFromQueue("overdue:remind", true);
    }

    /**
     * 从队列处理任务的通用方法
     */
    private void processTasksFromQueue(String queueKey, boolean isRemind) {
        try {
            long currentTime = System.currentTimeMillis();
            log.info("当前时间戳（毫秒）：{}", currentTime); // 例如：1728800000000（10月13日）
            var expiredTasks = redisTemplate.opsForZSet().rangeByScoreWithScores(queueKey, 0, currentTime);
            if (expiredTasks == null || expiredTasks.isEmpty()) {
                return;
            }

            log.info("开始处理{}任务，数量: {}", isRemind ? "提醒" : "超期", expiredTasks.size());

            for (var tuple : expiredTasks) {
                try {
                    @SuppressWarnings("unchecked")
                    Map<String, Object> taskData = com.alibaba.fastjson.JSON
                        .parseObject(tuple.getValue().toString(), Map.class);

                    String bizType = (String) taskData.get("bizType");
                    Long bizId = Long.valueOf(taskData.get("bizId").toString());

                    OverdueHandler handler = handlerMap.get(bizType);
                    if (handler != null) {
                        // 执行对应的处理逻辑
                        if (isRemind) {
                            handler.remindBeforeOverdue(bizId);
                        } else {
                            handler.handleOverdue(bizId);
                        }

                        // 处理完成后从队列中移除
                        redisTemplate.opsForZSet().remove(queueKey, tuple.getValue());

                        log.info("{}任务处理完成: bizType={}, bizId={}", isRemind ? "提醒" : "超期", bizType, bizId);
                    } else {
                        log.warn("未找到业务类型[{}]的处理器", bizType);
                        // 移除无效任务
                        redisTemplate.opsForZSet().remove(queueKey, tuple.getValue());
                    }

                } catch (Exception e) {
                    log.error("处理单个{}任务失败: {}", isRemind ? "提醒" : "超期", e.getMessage(), e);
                }


                //提醒


            }
        } catch (Exception e) {
            log.error("处理{}任务失败: {}", isRemind ? "提醒" : "超期", e.getMessage(), e);
        }
    }
}
